/*
Automatic clinic tests using a robot arm.
Copyright (C) 2010  CIC-CPC, CHU Gabriel Montpied
All other trademarks, logos and copyrights are the property
of their respective owners.

This file is part of cpc-painbot.

cpc-painbot is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

cpc-painbot is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with cpc-painbot.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef DETERMINATION_H
#define DETERMINATION_H

#include <QObject>

#include "seuil/methode.h"
#include "stimulation/stimulateur.h"

//! Espace concernant la détermination de seuil.
namespace seuil {

/*! Une Détermination de seuil.
    Une Détermination de seuil concerne soit la Douleur, la Tolérance ou la Sensibilité.
    Elle s'effectue selon une Méthode donnée : Up & Down, Potentiel Evoqué...
    Elle se fait grâce à un Stimulateur, sur une Zone donnée.
*/
class Determination : public QObject
{
Q_OBJECT
//! Méthode de Détermination.
Q_PROPERTY(Methode* methode READ methode WRITE setMethode)
//! Type de Détermination.
Q_PROPERTY(Type type READ type WRITE setType)

//! Stimulateur utilisé.
Q_PROPERTY(Stimulateur* stimulateur READ stimulateur WRITE setStimulateur)

Q_ENUMS(Type)

public:

    //! Les Types de Détermination.
    enum Type { Douleur, Tolerance, Sensibilite };

    //! Nombre de types de Détermination.
    static const int nbTypes = 3;

    /*! Convertit un type en une chaîne.
        \param[in] type le Type à convertir.
        \return Une chaîne de caractères correspondant à ce type.
    */
    static QString typeToString(Type type);

    /*! Crée une Détermination.
        Crée une Détermination à partir des différents types fournis, et fait les connections
        nécessaires entre ces objets.

        \param[in]  type        Type de la Détermination.
        \param[in]  methode     Type de la Methode.
        \param[in]  stimulateur Type du Stimulateur.
        \param      parent      Parent de la Détermination.

        \retval 0 La Détermination n'a pas pu être créée.
        \retval Determination* Une détermination avec les paramètres ci-dessus.
    */
    static Determination *creer(Type type, Methode::Type methode,
                                Stimulateur::Type stimulateur, QObject *parent = 0);

    //! Constructeur.
    explicit Determination(QObject *parent = 0);

    /*! Méthode utilisée.
        Méthode utilisée pour cette détermination.
        \return La Méthode utilisée.
    */
    Methode *methode() const { return methode_; }

    /*! Type de cette Détermination.
        \return Le Type de Détermination.
    */
    Type type() const { return type_; }

    /*! Stimulateur utilisé.
        \return Le Stimulateur utilisé.
    */
    Stimulateur *stimulateur() const { return stimulateur_; }

signals:

public slots:
    /*! Prépare la détermination.
        Prépare les différents éléments de la détermination.
    */
    void preparer();

    /*! Définit la Méthode à utiliser.
        \param methode Méthode à utiliser pour cette Détermination.
    */
    void setMethode(Methode *methode) { methode_ = methode; }

    /*! Définit le Type.
        \param[in] type Le Type de cette Détermination.
    */
    void setType(Type type) { type_ = type; }

    /*! Définit le Stimulateur.
        \param stimulateur Le Stimulateur à utiliser.
    */
    void setStimulateur(Stimulateur *stimulateur) { stimulateur_ = stimulateur; }

protected:
    Type type_; //!< Type de la Détermination.
    Methode *methode_; //!< Méthode de Détermination.
    Stimulateur *stimulateur_; //!< Stimulateur utilisé.
};

} // namespace seuil
#endif // DETERMINATION_H
